/*
 * Copyright (C) 2012 Wu Tong
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.cocoa4android.ui;

import java.util.List;

import org.cocoa4android.cg.CGPoint;
import org.cocoa4android.cg.CGRect;
import org.cocoa4android.cg.CGSize;
import org.cocoa4android.ns.NSSet;

import android.content.Context;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.FocusFinder;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.view.animation.AnimationUtils;
import android.widget.FrameLayout;
import android.widget.Scroller;

public class UIScrollView extends UIView {
	private HVScrollView scrollView = null;
	private UIView contentView = null;
	private CGSize contentSize;
	private UIScrollViewDelegate delegate;
	private boolean moveBegan = false;
	private boolean pageEnabled = false;
	
	
	public UIScrollView() {
		scrollView = new HVScrollView(context);
		scrollView.setPadding(0, 0, 0, 0);
		contentView = new UIView();
		scrollView.addView(contentView.getView());
		this.setView(scrollView);
		contentSize = new CGSize(0,0);
		canConsumeTouch = NO;
	}
	public UIScrollView(CGRect frame) {
		this();
		this.setFrame(frame);
	}
	
	public void setContentOffSet(CGPoint contentOffSet) {
		this.scrollView.scrollTo((int)(contentOffSet.x()*scaleDensityX), (int)(contentOffSet.y()*scaleDensityY));
	}
	public CGPoint contentOffSet() {
		return new CGPoint(scrollView.getScrollX()/scaleDensityX,scrollView.getScrollY()/scaleDensityY);
	}
	
	public void setContentSize(CGSize contentSize) {
		this.contentSize = contentSize;
		FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(
				(int)(contentSize.width()*scaleDensityX),
				(int)(contentSize.height()*scaleDensityY)
			);
		
		this.contentView.getView().setLayoutParams(params);
	}
	public CGSize contentSize() {
		return this.contentSize;
	}
	@Override
	public void addSubview(UIView child) {
		contentView.addSubview(child);
		if (UIWebView.class.isInstance(child)) {
			((UIWebView)child).setEnableMutipleScroll(YES);
		}else if(UITableView.class.isInstance(child)){
			((UITableView)child).setEnableMutipleScroll(YES);
		}
	}
	@Override
	public void removeSubView(UIView child) {
		contentView.removeSubView(child);
	}
	public void scrollRectToVisible(CGRect frame,boolean animated){
		scrollView.scrollToChildRect(frame.getRect(),!animated);
		if(!animated){
			if(delegate!=null){
				delegate.scrollViewDidEndDecelerating(this);
			}
		}
	}
	public UIScrollViewDelegate getDelegate() {
		return delegate;
	}
	public void setDelegate(UIScrollViewDelegate delegate) {
		this.delegate = delegate;
	}
	@Override
	public void touchesBegan(NSSet touches,UIEvent event){
		moveBegan = true;
	}
	@Override
	public void touchesMoved(NSSet touches,UIEvent event){
		if(moveBegan){
			if(delegate!=null){
				delegate.scrollViewWillBeginDragging(this);
			}
			moveBegan = false;
		}
		if(delegate!=null){
			delegate.scrollViewDidScroll(this);
		}
	}
	
	@Override
	public void touchesEnded(NSSet touches,UIEvent event){
		if(!moveBegan){
			if(delegate!=null){
				delegate.scrollViewDidEndDecelerating(this);
			}
			if(this.pageEnabled){
				CGRect frame = this.frame();
				
				float pageWidth = this.frame().size().width();
				int pagew = (int) (Math.floor((this.contentOffSet().x()-pageWidth/2)/pageWidth)+1);
				
				
				float pageHeight = this.frame().size().height();
				int pageh = (int) (Math.floor((this.contentOffSet().y()-pageHeight/2)/pageHeight)+1);
				
				int towardX = (int) (frame.size().width()*pagew);
				int towardY = (int) (frame.size().height()*pageh);
				
				scrollView.smoothScrollTo((int)(towardX*scaleDensityX), (int)(towardY*scaleDensityY));
				
			}
		}
		moveBegan = false;
	}
	
	public interface UIScrollViewDelegate {
		public void scrollViewDidScroll(UIScrollView scrollView);
		
		public void scrollViewWillBeginDragging(UIScrollView scrollView);
		
		public void scrollViewDidEndDecelerating(UIScrollView scrollView);
		
	}
	
	public void setShowsHorizontalScrollIndicator(boolean showsHorizontalScrollIndicator){
		this.scrollView.setHorizontalScrollBarEnabled(showsHorizontalScrollIndicator);
	}
	
	public void setShowsVerticalScrollIndicator(boolean showsVerticalScrollIndicator){
		this.scrollView.setVerticalScrollBarEnabled(showsVerticalScrollIndicator);
	}
	public boolean isPageEnabled() {
		return pageEnabled;
	}
	public void setPageEnabled(boolean pageEnabled) {
		this.pageEnabled = pageEnabled;
		this.scrollView.setFlingEnabled(!pageEnabled);
	}
	
	
	
	public class HVScrollView extends FrameLayout {  
		static final int ANIMATED_SCROLL_GAP = 250;  

		static final float MAX_SCROLL_FACTOR = 0.5f;  


		private long mLastScroll;  

		private final Rect mTempRect = new Rect();  
		private Scroller mScroller;  

		/** 
		 * Flag to indicate that we are moving focus ourselves. This is so the 
		 * code that watches for focus changes initiated outside this ScrollView 
		 * knows that it does not have to do anything. 
		 */  
		private boolean mScrollViewMovedFocus;  

		/** 
		 * Position of the last motion event. 
		 */  
		private float mLastMotionY;  
		private float mLastMotionX;  

		/** 
		 * True when the layout has changed but the traversal has not come through yet. 
		 * Ideally the view hierarchy would keep track of this for us. 
		 */  
		private boolean mIsLayoutDirty = true;  

		/** 
		 * The child to give focus to in the event that a child has requested focus while the 
		 * layout is dirty. This prevents the scroll from being wrong if the child has not been 
		 * laid out before requesting focus. 
		 */  
		private View mChildToScrollTo = null;  

		/** 
		 * True if the user is currently dragging this ScrollView around. This is 
		 * not the same as 'is being flinged', which can be checked by 
		 * mScroller.isFinished() (flinging begins when the user lifts his finger). 
		 */  
		private boolean mIsBeingDragged = false;  

		/** 
		 * Determines speed during touch scrolling 
		 */  
		private VelocityTracker mVelocityTracker;  

		/** 
		 * When set to true, the scroll view measure its child to make it fill the currently 
		 * visible area. 
		 */  
		private boolean mFillViewport;  

		/** 
		 * Whether arrow scrolling is animated. 
		 */  
		private boolean mSmoothScrollingEnabled = true;  

		private int mTouchSlop;  
		private int mMinimumVelocity;  
		private int mMaximumVelocity;  

		/** 
		 * ID of the active pointer. This is used to retain consistency during 
		 * drags/flings if multiple pointers are used. 
		 */  
		private int mActivePointerId = INVALID_POINTER;  

		/** 
		 * Sentinel value for no current active pointer. 
		 * Used by {@link #mActivePointerId}. 
		 */  
		private static final int INVALID_POINTER = -1;  

		private boolean mFlingEnabled = true;  

		public HVScrollView(Context context) {  
			this(context, null);  
		}  

		public HVScrollView(Context context, AttributeSet attrs) {  
			super(context, attrs);  
			initScrollView();  
		}  

		@Override  
		protected float getTopFadingEdgeStrength() {  
			if (getChildCount() == 0) {  
				return 0.0f;  
			}  

			final int length = getVerticalFadingEdgeLength();  
			if (getScrollY() < length) {  
				return getScrollY() / (float) length;  
			}  

			return 1.0f;  
		}  

		@Override  
		protected float getLeftFadingEdgeStrength() {  
			if (getChildCount() == 0) {  
				return 0.0f;  
			}  

			final int length = getHorizontalFadingEdgeLength();  
			if (getScrollX() < length) {  
				return getScrollX() / (float) length;  
			}  

			return 1.0f;  
		}  

		@Override  
		protected float getRightFadingEdgeStrength() {  
			if (getChildCount() == 0) {  
				return 0.0f;  
			}  

			final int length = getHorizontalFadingEdgeLength();  
			final int rightEdge = getWidth() - getPaddingRight();  
			final int span = getChildAt(0).getRight() - getScrollX() - rightEdge;  
			if (span < length) {  
				return span / (float) length;  
			}  

			return 1.0f;  
		}  

		@Override  
		protected float getBottomFadingEdgeStrength() {  
			if (getChildCount() == 0) {  
				return 0.0f;  
			}  

			final int length = getVerticalFadingEdgeLength();  
			final int bottomEdge = getHeight() - getPaddingBottom();  
			final int span = getChildAt(0).getBottom() - getScrollY() - bottomEdge;  
			if (span < length) {  
				return span / (float) length;  
			}  

			return 1.0f;  
		}  

		/** 
		 * @return The maximum amount this scroll view will scroll in response to 
		 *   an arrow event. 
		 */  
		 public int getMaxScrollAmountV() {  
			return (int) (MAX_SCROLL_FACTOR * (getBottom() - getTop()));  
		}  

		public int getMaxScrollAmountH() {  
			return (int) (MAX_SCROLL_FACTOR * (getRight() - getLeft()));  
		}  


		private void initScrollView() {  
			mScroller = new Scroller(getContext());  
			setFocusable(true);  
			setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);  
			setWillNotDraw(false);  
			final ViewConfiguration configuration = ViewConfiguration.get(getContext());  
			mTouchSlop = configuration.getScaledTouchSlop();  
			mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();  
			mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();  
		}  

		@Override  
		public void addView(View child) {  
			if (getChildCount() > 0) {  
				throw new IllegalStateException("ScrollView can host only one direct child");  
			}  

			super.addView(child);  
		}  

		@Override  
		public void addView(View child, int index) {  
			if (getChildCount() > 0) {  
				throw new IllegalStateException("ScrollView can host only one direct child");  
			}  

			super.addView(child, index);  
		}  

		@Override  
		public void addView(View child, ViewGroup.LayoutParams params) {  
			if (getChildCount() > 0) {  
				throw new IllegalStateException("ScrollView can host only one direct child");  
			}  

			super.addView(child, params);  
		}  

		@Override  
		public void addView(View child, int index, ViewGroup.LayoutParams params) {  
			if (getChildCount() > 0) {  
				throw new IllegalStateException("ScrollView can host only one direct child");  
			}  

			super.addView(child, index, params);  
		}  

		/** 
		 * @return Returns true this ScrollView can be scrolled 
		 */  
		private boolean canScrollV() {  
			View child = getChildAt(0);
			if (child != null) {  
				int childHeight = child.getHeight();  
				return getHeight() < childHeight + getPaddingTop() + getPaddingBottom();  
			}  
			return false;  
		}  

		private boolean canScrollH() {  
			View child = getChildAt(0);  
			if (child != null) {  
				int childWidth = child.getWidth();  
				return getWidth() < childWidth + getPaddingLeft() + getPaddingRight() ;  
			}  
			return false;  
		}  

		/** 
		 * Indicates whether this ScrollView's content is stretched to fill the viewport. 
		 * 
		 * @return True if the content fills the viewport, false otherwise. 
		 */  
		public boolean isFillViewport() {  
			return mFillViewport;  
		}  

		/** 
		 * Indicates this ScrollView whether it should stretch its content height to fill 
		 * the viewport or not. 
		 * 
		 * @param fillViewport True to stretch the content's height to the viewport's 
		 *        boundaries, false otherwise. 
		 */  
		public void setFillViewport(boolean fillViewport) {  
			if (fillViewport != mFillViewport) {  
				mFillViewport = fillViewport;  
				requestLayout();  
			}  
		}  

		/** 
		 * @return Whether arrow scrolling will animate its transition. 
		 */  
		public boolean isSmoothScrollingEnabled() {  
			return mSmoothScrollingEnabled;  
		}  

		/** 
		 * Set whether arrow scrolling will animate its transition. 
		 * @param smoothScrollingEnabled whether arrow scrolling will animate its transition 
		 */  
		public void setSmoothScrollingEnabled(boolean smoothScrollingEnabled) {  
			mSmoothScrollingEnabled = smoothScrollingEnabled;  
		}  

		@Override  
		protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
			super.onMeasure(widthMeasureSpec, heightMeasureSpec);  

			if (!mFillViewport) {  
				return;  
			}  

			final int heightMode = MeasureSpec.getMode(heightMeasureSpec);  
			final int widthMode = MeasureSpec.getMode(widthMeasureSpec);  
			if (heightMode == MeasureSpec.UNSPECIFIED && widthMode == MeasureSpec.UNSPECIFIED) {  
				return;  
			}  

			if (getChildCount() > 0) {  
				final View child = getChildAt(0);  
				int height = getMeasuredHeight();  
				int width = getMeasuredWidth();  
				if (child.getMeasuredHeight() < height || child.getMeasuredWidth() < width) {  
					width -= getPaddingLeft();  
					width -= getPaddingRight();  
					int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY);  

					height -= getPaddingTop();  
					height -= getPaddingBottom();  
					int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);  

					child.measure(childWidthMeasureSpec, childHeightMeasureSpec);  
				}  
			}  
		}  
		@Override  
		public boolean dispatchKeyEvent(KeyEvent event) {  
			// Let the focused view and/or our descendants get the key first  
			return super.dispatchKeyEvent(event) || executeKeyEvent(event);  
		}  

		/** 
		 * You can call this function yourself to have the scroll view perform 
		 * scrolling from a key event, just as if the event had been dispatched to 
		 * it by the view hierarchy. 
		 * 
		 * @param event The key event to execute. 
		 * @return Return true if the event was handled, else false. 
		 */  
		public boolean executeKeyEvent(KeyEvent event) {  
			mTempRect.setEmpty();  

			boolean handled = false;  

			if (event.getAction() == KeyEvent.ACTION_DOWN) {  
				switch (event.getKeyCode()) {  
				case KeyEvent.KEYCODE_DPAD_LEFT:  
					if(canScrollH()){  
						if (!event.isAltPressed()) {  
							handled = arrowScrollH(View.FOCUS_LEFT);  
						} else {  
							handled = fullScrollH(View.FOCUS_LEFT);  
						}  
					}  
					break;  
				case KeyEvent.KEYCODE_DPAD_RIGHT:  
					if(canScrollH()){  
						if (!event.isAltPressed()) {  
							handled = arrowScrollH(View.FOCUS_RIGHT);  
						} else {  
							handled = fullScrollH(View.FOCUS_RIGHT);  
						}  
					}  
					break;  
				case KeyEvent.KEYCODE_DPAD_UP:  
					if(canScrollV()){  
						if (!event.isAltPressed()) {  
							handled = arrowScrollV(View.FOCUS_UP);  
						} else {  
							handled = fullScrollV(View.FOCUS_UP);  
						}  
					}  
					break;  
				case KeyEvent.KEYCODE_DPAD_DOWN:  
					if(canScrollV()){  
						if (!event.isAltPressed()) {  
							handled = arrowScrollV(View.FOCUS_DOWN);  
						} else {  
							handled = fullScrollV(View.FOCUS_DOWN);  
						}  
					}  
					break;  
				}  
			}  
			return handled;  
		}  

		private boolean inChild(int x, int y) {  
			if (getChildCount() > 0) {  
				final int scrollX = getScrollX();  
				final int scrollY = getScrollY();  
				final View child = getChildAt(0);  
				return !(y < child.getTop() - scrollY  
						|| y >= child.getBottom() - scrollY  
						|| x < child.getLeft() - scrollX  
						|| x >= child.getRight() - scrollX);  
			}  
			return false;  
		}  

		@Override  
		public boolean onInterceptTouchEvent(MotionEvent ev) {  
			/* 
			 * This method JUST determines whether we want to intercept the motion. 
			 * If we return true, onMotionEvent will be called and we do the actual 
			 * scrolling there. 
			 */  

			/* 
			 * Shortcut the most recurring case: the user is in the dragging 
			 * state and he is moving his finger.  We want to intercept this 
			 * motion. 
			 */  
			final int action = ev.getAction();  
			if ((action == MotionEvent.ACTION_MOVE) && (mIsBeingDragged)) {  
				return true;  
			}  

			switch (action & MotionEvent.ACTION_MASK) {  
			case MotionEvent.ACTION_MOVE: {  
				/* 
				 * mIsBeingDragged == false, otherwise the shortcut would have caught it. Check 
				 * whether the user has moved far enough from his original down touch. 
				 */  

				/* 
				 * Locally do absolute value. mLastMotionY is set to the y value 
				 * of the down event. 
				 */  
				final int activePointerId = mActivePointerId;  
				if (activePointerId == INVALID_POINTER) {  
					// If we don't have a valid id, the touch down wasn't on content.  
					break;  
				}  

				final int pointerIndex = ev.findPointerIndex(activePointerId);  
				final float y = ev.getY(pointerIndex);  
				final int yDiff = (int) Math.abs(y - mLastMotionY);  
				if (yDiff > mTouchSlop) {  
					mIsBeingDragged = true;  
					mLastMotionY = y;  
				}  
				final float x = ev.getX(pointerIndex);  
				final int xDiff = (int) Math.abs(x - mLastMotionX);  
				if (xDiff > mTouchSlop) {  
					mIsBeingDragged = true;  
					mLastMotionX = x;  
				}  
				break;  
			}  

			case MotionEvent.ACTION_DOWN: {  
				final float x = ev.getX();  
				final float y = ev.getY();  
				if (!inChild((int)x, (int) y)) {  
					mIsBeingDragged = false;  
					break;  
				}  

				/* 
				 * Remember location of down touch. 
				 * ACTION_DOWN always refers to pointer index 0. 
				 */  
				mLastMotionY = y;  
				mLastMotionX = x;  
				mActivePointerId = ev.getPointerId(0);  

				/* 
				 * If being flinged and user touches the screen, initiate drag; 
				 * otherwise don't.  mScroller.isFinished should be false when 
				 * being flinged. 
				 */  
				mIsBeingDragged = !mScroller.isFinished();  
				break;  
			}  

			case MotionEvent.ACTION_CANCEL:  
			case MotionEvent.ACTION_UP:  
				/* Release the drag */  
				mIsBeingDragged = false;  
				mActivePointerId = INVALID_POINTER;  
				break;  
			case MotionEvent.ACTION_POINTER_UP:  
				onSecondaryPointerUp(ev);  
				break;  
			}  

			/* 
			 * The only time we want to intercept motion events is if we are in the 
			 * drag mode. 
			 */  
			return mIsBeingDragged;  
		}  

		@Override  
		public boolean onTouchEvent(MotionEvent ev) {  
			if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {  
				// Don't handle edge touches immediately -- they may actually belong to one of our  
				// descendants.  
				return false;  
			}  

			if (mVelocityTracker == null) {  
				mVelocityTracker = VelocityTracker.obtain();  
			}  
			mVelocityTracker.addMovement(ev);  

			final int action = ev.getAction();  

			switch (action & MotionEvent.ACTION_MASK) {  
			case MotionEvent.ACTION_DOWN: {  
				final float x = ev.getX();  
				final float y = ev.getY();  
				if (!(mIsBeingDragged = inChild((int) x, (int) y))) {  
					return false;  
				}  

				/* 
				 * If being flinged and user touches, stop the fling. isFinished 
				 * will be false if being flinged. 
				 */  
				if (!mScroller.isFinished()) {  
					mScroller.abortAnimation();  
				}  

				// Remember where the motion event started  
				mLastMotionY = y;  
				mLastMotionX = x;  
				mActivePointerId = ev.getPointerId(0);  
				break;  
			}  
			case MotionEvent.ACTION_MOVE:  
				if (mIsBeingDragged) {  
					// Scroll to follow the motion event  
					final int activePointerIndex = ev.findPointerIndex(mActivePointerId);  
					final float y = ev.getY(activePointerIndex);  
					final int deltaY = (int) (mLastMotionY - y);  
					mLastMotionY = y;  

					final float x = ev.getX(activePointerIndex);  
					final int deltaX = (int) (mLastMotionX - x);  
					mLastMotionX = x;  

					scrollBy(deltaX, deltaY);  
				}  
				break;  
			case MotionEvent.ACTION_UP:   
				if (mIsBeingDragged) {  
					if(mFlingEnabled){  
						final VelocityTracker velocityTracker = mVelocityTracker;  
						velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);  
						int initialVelocitx = (int) velocityTracker.getXVelocity();  
						int initialVelocity = (int) velocityTracker.getYVelocity(); 
//						int initialVelocitx = (int) velocityTracker.getXVelocity(mActivePointerId);  
//						int initialVelocity = (int) velocityTracker.getYVelocity(mActivePointerId);  

						if (getChildCount() > 0) {  
							if(Math.abs(initialVelocitx) > initialVelocitx || Math.abs(initialVelocity) > mMinimumVelocity) {  
								fling(-initialVelocitx, -initialVelocity);  
							}  

						}  
					}  

					mActivePointerId = INVALID_POINTER;  
					mIsBeingDragged = false;  

					if (mVelocityTracker != null) {  
						mVelocityTracker.recycle();  
						mVelocityTracker = null;  
					}  
				}  
				break;  
			case MotionEvent.ACTION_CANCEL:  
				if (mIsBeingDragged && getChildCount() > 0) {  
					mActivePointerId = INVALID_POINTER;  
					mIsBeingDragged = false;  
					if (mVelocityTracker != null) {  
						mVelocityTracker.recycle();  
						mVelocityTracker = null;  
					}  
				}  
				break;  
			case MotionEvent.ACTION_POINTER_UP:  
				onSecondaryPointerUp(ev);  
				break;  
			}  
			return true;  
		}  

		private void onSecondaryPointerUp(MotionEvent ev) {  
			final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_ID_MASK) >>  
			MotionEvent.ACTION_POINTER_ID_SHIFT;  
			final int pointerId = ev.getPointerId(pointerIndex);  
			if (pointerId == mActivePointerId) {  
				// This was our active pointer going up. Choose a new  
				// active pointer and adjust accordingly.  
				final int newPointerIndex = pointerIndex == 0 ? 1 : 0;  
				mLastMotionX = ev.getX(newPointerIndex);  
				mLastMotionY = ev.getY(newPointerIndex);  
				mActivePointerId = ev.getPointerId(newPointerIndex);  
				if (mVelocityTracker != null) {  
					mVelocityTracker.clear();  
				}  
			}  
		} 
		/** 
		 * <p> 
		 * Finds the next focusable component that fits in the specified bounds. 
		 * </p> 
		 * 
		 * @param topFocus look for a candidate is the one at the top of the bounds 
		 *                 if topFocus is true, or at the bottom of the bounds if topFocus is 
		 *                 false 
		 * @param top      the top offset of the bounds in which a focusable must be 
		 *                 found 
		 * @param bottom   the bottom offset of the bounds in which a focusable must 
		 *                 be found 
		 * @return the next focusable component in the bounds or null if none can 
		 *         be found 
		 */  
		private View findFocusableViewInBoundsV(boolean topFocus, int top, int bottom) {  

			List<View> focusables = getFocusables(View.FOCUS_FORWARD);  
			View focusCandidate = null;  

			/* 
			 * A fully contained focusable is one where its top is below the bound's 
			 * top, and its bottom is above the bound's bottom. A partially 
			 * contained focusable is one where some part of it is within the 
			 * bounds, but it also has some part that is not within bounds.  A fully contained 
			 * focusable is preferred to a partially contained focusable. 
			 */  
			boolean foundFullyContainedFocusable = false;  

			int count = focusables.size();  
			for (int i = 0; i < count; i++) {  
				View view = focusables.get(i);  
				int viewTop = view.getTop();  
				int viewBottom = view.getBottom();  

				if (top < viewBottom && viewTop < bottom) {  
					/* 
					 * the focusable is in the target area, it is a candidate for 
					 * focusing 
					 */  

					final boolean viewIsFullyContained = (top < viewTop) &&  
					(viewBottom < bottom);  

					if (focusCandidate == null) {  
						/* No candidate, take this one */  
						focusCandidate = view;  
						foundFullyContainedFocusable = viewIsFullyContained;  
					} else {  
						final boolean viewIsCloserToBoundary =  
							(topFocus && viewTop < focusCandidate.getTop()) ||  
							(!topFocus && viewBottom > focusCandidate  
									.getBottom());  

						if (foundFullyContainedFocusable) {  
							if (viewIsFullyContained && viewIsCloserToBoundary) {  
								/* 
								 * We're dealing with only fully contained views, so 
								 * it has to be closer to the boundary to beat our 
								 * candidate 
								 */  
								focusCandidate = view;  
							}  
						} else {  
							if (viewIsFullyContained) {  
								/* Any fully contained view beats a partially contained view */  
								focusCandidate = view;  
								foundFullyContainedFocusable = true;  
							} else if (viewIsCloserToBoundary) {  
								/* 
								 * Partially contained view beats another partially 
								 * contained view if it's closer 
								 */  
								focusCandidate = view;  
							}  
						}  
					}  
				}  
			}  

			return focusCandidate;  
		}  

		private View findFocusableViewInBoundsH(boolean leftFocus, int left, int right) {  

			List<View> focusables = getFocusables(View.FOCUS_FORWARD);  
			View focusCandidate = null;  

			/* 
			 * A fully contained focusable is one where its left is below the bound's 
			 * left, and its right is above the bound's right. A partially 
			 * contained focusable is one where some part of it is within the 
			 * bounds, but it also has some part that is not within bounds.  A fully contained 
			 * focusable is preferred to a partially contained focusable. 
			 */  
			boolean foundFullyContainedFocusable = false;  

			int count = focusables.size();  
			for (int i = 0; i < count; i++) {  
				View view = focusables.get(i);  
				int viewLeft = view.getLeft();  
				int viewRight = view.getRight();  

				if (left < viewRight && viewLeft < right) {  
					/* 
					 * the focusable is in the target area, it is a candidate for 
					 * focusing 
					 */  

					final boolean viewIsFullyContained = (left < viewLeft) &&  
					(viewRight < right);  

					if (focusCandidate == null) {  
						/* No candidate, take this one */  
						focusCandidate = view;  
						foundFullyContainedFocusable = viewIsFullyContained;  
					} else {  
						final boolean viewIsCloserToBoundary =  
							(leftFocus && viewLeft < focusCandidate.getLeft()) ||  
							(!leftFocus && viewRight > focusCandidate.getRight());  

						if (foundFullyContainedFocusable) {  
							if (viewIsFullyContained && viewIsCloserToBoundary) {  
								/* 
								 * We're dealing with only fully contained views, so 
								 * it has to be closer to the boundary to beat our 
								 * candidate 
								 */  
								focusCandidate = view;  
							}  
						} else {  
							if (viewIsFullyContained) {  
								/* Any fully contained view beats a partially contained view */  
								focusCandidate = view;  
								foundFullyContainedFocusable = true;  
							} else if (viewIsCloserToBoundary) {  
								/* 
								 * Partially contained view beats another partially 
								 * contained view if it's closer 
								 */  
								focusCandidate = view;  
							}  
						}  
					}  
				}  
			}  

			return focusCandidate;  
		}  

		/** 
		 * <p>Handles scrolling in response to a "home/end" shortcut press. This 
		 * method will scroll the view to the top or bottom and give the focus 
		 * to the topmost/bottommost component in the new visible area. If no 
		 * component is a good candidate for focus, this scrollview reclaims the 
		 * focus.</p> 
		 * 
		 * @param direction the scroll direction: {@link android.view.View#FOCUS_UP} 
		 *                  to go the top of the view or 
		 *                  {@link android.view.View#FOCUS_DOWN} to go the bottom 
		 * @return true if the key event is consumed by this method, false otherwise 
		 */  
		public boolean fullScrollV(int direction) {  
			boolean down = direction == View.FOCUS_DOWN;  
			int height = getHeight();  

			mTempRect.top = 0;  
			mTempRect.bottom = height;  

			if (down) {  
				int count = getChildCount();  
				if (count > 0) {  
					View view = getChildAt(count - 1);  
					mTempRect.bottom = view.getBottom();  
					mTempRect.top = mTempRect.bottom - height;  
				}  
			}  

			return scrollAndFocusV(direction, mTempRect.top, mTempRect.bottom);  
		}  

		public boolean fullScrollH(int direction) {  
			boolean right = direction == View.FOCUS_RIGHT;  
			int width = getWidth();  

			mTempRect.left = 0;  
			mTempRect.right = width;  

			if (right) {  
				int count = getChildCount();  
				if (count > 0) {  
					View view = getChildAt(0);  
					mTempRect.right = view.getRight();  
					mTempRect.left = mTempRect.right - width;  
				}  
			}  

			return scrollAndFocusH(direction, mTempRect.left, mTempRect.right);  
		}  

		/** 
		 * <p>Scrolls the view to make the area defined by <code>top</code> and 
		 * <code>bottom</code> visible. This method attempts to give the focus 
		 * to a component visible in this area. If no component can be focused in 
		 * the new visible area, the focus is reclaimed by this scrollview.</p> 
		 * 
		 * @param direction the scroll direction: {@link android.view.View#FOCUS_UP} 
		 *                  to go upward 
		 *                  {@link android.view.View#FOCUS_DOWN} to downward 
		 * @param top       the top offset of the new area to be made visible 
		 * @param bottom    the bottom offset of the new area to be made visible 
		 * @return true if the key event is consumed by this method, false otherwise 
		 */  
		private boolean scrollAndFocusV(int direction, int top, int bottom) {  
			boolean handled = true;  

			int height = getHeight();  
			int containerTop = getScrollY();  
			int containerBottom = containerTop + height;  
			boolean up = direction == View.FOCUS_UP;  

			View newFocused = findFocusableViewInBoundsV(up, top, bottom);  
			if (newFocused == null) {  
				newFocused = this;  
			}  

			if (top >= containerTop && bottom <= containerBottom) {  
				handled = false;  
			} else {  
				int delta = up ? (top - containerTop) : (bottom - containerBottom);  
				doScrollY(delta);  
			}  

			if (newFocused != findFocus() && newFocused.requestFocus(direction)) {  
				mScrollViewMovedFocus = true;  
				mScrollViewMovedFocus = false;  
			}  

			return handled;  
		}  

		private boolean scrollAndFocusH(int direction, int left, int right) {  
			boolean handled = true;  

			int width = getWidth();  
			int containerLeft = getScrollX();  
			int containerRight = containerLeft + width;  
			boolean goLeft = direction == View.FOCUS_LEFT;  

			View newFocused = findFocusableViewInBoundsH(goLeft, left, right);  
			if (newFocused == null) {  
				newFocused = this;  
			}  

			if (left >= containerLeft && right <= containerRight) {  
				handled = false;  
			} else {  
				int delta = goLeft ? (left - containerLeft) : (right - containerRight);  
				doScrollX(delta);  
			}  

			if (newFocused != findFocus() && newFocused.requestFocus(direction)) {  
				mScrollViewMovedFocus = true;  
				mScrollViewMovedFocus = false;  
			}  

			return handled;  
		}  

		/** 
		 * Handle scrolling in response to an up or down arrow click. 
		 * 
		 * @param direction The direction corresponding to the arrow key that was 
		 *                  pressed 
		 * @return True if we consumed the event, false otherwise 
		 */  
		public boolean arrowScrollV(int direction) {  

			View currentFocused = findFocus();  
			if (currentFocused == this) currentFocused = null;  

			View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);  

			final int maxJump = getMaxScrollAmountV();  

			if (nextFocused != null && isWithinDeltaOfScreenV(nextFocused, maxJump, getHeight())) {  
				nextFocused.getDrawingRect(mTempRect);  
				offsetDescendantRectToMyCoords(nextFocused, mTempRect);  
				int scrollDelta = computeScrollDeltaToGetChildRectOnScreenV(mTempRect);  
				doScrollY(scrollDelta);  
				nextFocused.requestFocus(direction);  
			} else {  
				// no new focus  
				int scrollDelta = maxJump;  

				if (direction == View.FOCUS_UP && getScrollY() < scrollDelta) {  
					scrollDelta = getScrollY();  
				} else if (direction == View.FOCUS_DOWN) {  
					if (getChildCount() > 0) {  
						int daBottom = getChildAt(0).getBottom();  

						int screenBottom = getScrollY() + getHeight();  

						if (daBottom - screenBottom < maxJump) {  
							scrollDelta = daBottom - screenBottom;  
						}  
					}  
				}  
				if (scrollDelta == 0) {  
					return false;  
				}  
				doScrollY(direction == View.FOCUS_DOWN ? scrollDelta : -scrollDelta);  
			}  

			if (currentFocused != null && currentFocused.isFocused()  
					&& isOffScreenV(currentFocused)) {  
				// previously focused item still has focus and is off screen, give  
				// it up (take it back to ourselves)  
				// (also, need to temporarily force FOCUS_BEFORE_DESCENDANTS so we are  
				// sure to  
				// get it)  
				final int descendantFocusability = getDescendantFocusability();  // save  
				setDescendantFocusability(ViewGroup.FOCUS_BEFORE_DESCENDANTS);  
				requestFocus();  
				setDescendantFocusability(descendantFocusability);  // restore  
			}  
			return true;  
		}  

		public boolean arrowScrollH(int direction) {  

			View currentFocused = findFocus();  
			if (currentFocused == this) currentFocused = null;  

			View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction);  

			final int maxJump = getMaxScrollAmountH();  

			if (nextFocused != null && isWithinDeltaOfScreenH(nextFocused, maxJump)) {  
				nextFocused.getDrawingRect(mTempRect);  
				offsetDescendantRectToMyCoords(nextFocused, mTempRect);  
				int scrollDelta = computeScrollDeltaToGetChildRectOnScreenH(mTempRect);  
				doScrollX(scrollDelta);  
				nextFocused.requestFocus(direction);  
			} else {  
				// no new focus  
				int scrollDelta = maxJump;  

				if (direction == View.FOCUS_LEFT && getScrollX() < scrollDelta) {  
					scrollDelta = getScrollX();  
				} else if (direction == View.FOCUS_RIGHT && getChildCount() > 0) {  

					int daRight = getChildAt(0).getRight();  

					int screenRight = getScrollX() + getWidth();  

					if (daRight - screenRight < maxJump) {  
						scrollDelta = daRight - screenRight;  
					}  
				}  
				if (scrollDelta == 0) {  
					return false;  
				}  
				doScrollX(direction == View.FOCUS_RIGHT ? scrollDelta : -scrollDelta);  
			}  

			if (currentFocused != null && currentFocused.isFocused()  
					&& isOffScreenH(currentFocused)) {  
				// previously focused item still has focus and is off screen, give  
				// it up (take it back to ourselves)  
				// (also, need to temporarily force FOCUS_BEFORE_DESCENDANTS so we are  
				// sure to  
				// get it)  
				final int descendantFocusability = getDescendantFocusability();  // save  
				setDescendantFocusability(ViewGroup.FOCUS_BEFORE_DESCENDANTS);  
				requestFocus();  
				setDescendantFocusability(descendantFocusability);  // restore  
			}  
			return true;  
		}
		/** 
		 * @return whether the descendant of this scroll view is scrolled off 
		 *  screen. 
		 */  
		private boolean isOffScreenV(View descendant) {  
			return !isWithinDeltaOfScreenV(descendant, 0, getHeight());  
		}  

		private boolean isOffScreenH(View descendant) {  
			return !isWithinDeltaOfScreenH(descendant, 0);  
		}  

		/** 
		 * @return whether the descendant of this scroll view is within delta 
		 *  pixels of being on the screen. 
		 */  
		private boolean isWithinDeltaOfScreenV(View descendant, int delta, int height) {  
			descendant.getDrawingRect(mTempRect);  
			offsetDescendantRectToMyCoords(descendant, mTempRect);  

			return (mTempRect.bottom + delta) >= getScrollY()  
			&& (mTempRect.top - delta) <= (getScrollY() + height);  
		}  

		private boolean isWithinDeltaOfScreenH(View descendant, int delta) {  
			descendant.getDrawingRect(mTempRect);  
			offsetDescendantRectToMyCoords(descendant, mTempRect);  

			return (mTempRect.right + delta) >= getScrollX()  
			&& (mTempRect.left - delta) <= (getScrollX() + getWidth());  
		}  

		/** 
		 * Smooth scroll by a Y delta 
		 * 
		 * @param delta the number of pixels to scroll by on the Y axis 
		 */  
		private void doScrollY(int delta) {  
			if (delta != 0) {  
				if (mSmoothScrollingEnabled) {  
					smoothScrollBy(0, delta);  
				} else {  
					scrollBy(0, delta);  
				}  
			}  
		}  

		private void doScrollX(int delta) {  
			if (delta != 0) {  
				if (mSmoothScrollingEnabled) {  
					smoothScrollBy(delta, 0);  
				} else {  
					scrollBy(delta, 0);  
				}  
			}  
		}  

		/** 
		 * Like {@link View#scrollBy}, but scroll smoothly instead of immediately. 
		 * 
		 * @param dx the number of pixels to scroll by on the X axis 
		 * @param dy the number of pixels to scroll by on the Y axis 
		 */  
		public void smoothScrollBy(int dx, int dy) {  
			if (getChildCount() == 0) {  
				// Nothing to do.  
				return;  
			}  
			if (!mScroller.isFinished()) {  
				mScroller.abortAnimation();  
			}
			long duration = AnimationUtils.currentAnimationTimeMillis() - mLastScroll;  
			if (duration > ANIMATED_SCROLL_GAP) {  
				final int height = getHeight() - getPaddingBottom() - getPaddingTop();  
				final int bottom = getChildAt(0).getHeight();  
				final int maxY = Math.max(0, bottom - height);  
				final int scrollY = getScrollY();  
				dy = Math.max(0, Math.min(scrollY + dy, maxY)) - scrollY;  

				final int width = getWidth() - getPaddingRight() - getPaddingLeft();  
				final int right = getChildAt(0).getWidth();  
				final int maxX = Math.max(0, right - width);  
				final int scrollX = getScrollX();  
				dx = Math.max(0, Math.min(scrollX + dx, maxX)) - scrollX;  

				mScroller.startScroll(scrollX, scrollY, dx, dy);
				this.computeScroll();
				invalidate();  
				
			} else {  
				if (!mScroller.isFinished()) {  
					mScroller.abortAnimation();  
				}  
				scrollBy(dx, dy);
			}  
			mLastScroll = AnimationUtils.currentAnimationTimeMillis();  
		}  

		/** 
		 * Like {@link #scrollTo}, but scroll smoothly instead of immediately. 
		 * 
		 * @param x the position where to scroll on the X axis 
		 * @param y the position where to scroll on the Y axis 
		 */  
		public final void smoothScrollTo(int x, int y) {  
			smoothScrollBy(x - getScrollX(), y - getScrollY());  
		}  

		/** 
		 * <p>The scroll range of a scroll view is the overall height of all of its 
		 * children.</p> 
		 */  
		@Override  
		protected int computeVerticalScrollRange() {  
			final int count = getChildCount();  
			final int contentHeight = getHeight() - getPaddingBottom() - getPaddingTop();  
			if (count == 0) {  
				return contentHeight;  
			}  

			return getChildAt(0).getBottom();  
		}  

		@Override  
		protected int computeHorizontalScrollRange() {  
			final int count = getChildCount();  
			final int contentWidth = getWidth() - getPaddingLeft() - getPaddingRight();  
			if (count == 0) {  
				return contentWidth;  
			}  

			return getChildAt(0).getRight();  
		}  

		@Override  
		protected int computeVerticalScrollOffset() {  
			return Math.max(0, super.computeVerticalScrollOffset());  
		}  

		@Override  
		protected int computeHorizontalScrollOffset() {  
			return Math.max(0, super.computeHorizontalScrollOffset());  
		}  

		@Override  
		protected void measureChild(View child, int parentWidthMeasureSpec, int parentHeightMeasureSpec) {  
			int childWidthMeasureSpec;  
			int childHeightMeasureSpec;  

			childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);  

			childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);  

			child.measure(childWidthMeasureSpec, childHeightMeasureSpec);  
		}  

		@Override  
		protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed,  
				int parentHeightMeasureSpec, int heightUsed) {  
			final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();  

			final int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(  
					lp.leftMargin + lp.rightMargin, MeasureSpec.UNSPECIFIED);  
			final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(  
					lp.topMargin + lp.bottomMargin, MeasureSpec.UNSPECIFIED);  

			child.measure(childWidthMeasureSpec, childHeightMeasureSpec);  
		}  

		@Override  
		public void computeScroll() {  
			if (mScroller.computeScrollOffset()) {  
				// This is called at drawing time by ViewGroup.  We don't want to  
				// re-show the scrollbars at this point, which scrollTo will do,  
				// so we replicate most of scrollTo here.  
				//  
				//         It's a little odd to call onScrollChanged from inside the drawing.  
				//  
				//         It is, except when you remember that computeScroll() is used to  
				//         animate scrolling. So unless we want to defer the onScrollChanged()  
				//         until the end of the animated scrolling, we don't really have a  
				//         choice here.  
				//  
				//         I agree.  The alternative, which I think would be worse, is to post  
				//         something and tell the subclasses later.  This is bad because there  
				//         will be a window where mScrollX/Y is different from what the app  
				//         thinks it is.  
				//  
				int x = mScroller.getCurrX();  
				int y = mScroller.getCurrY();  

				if (getChildCount() > 0) {  
					View child = getChildAt(0);  
					x = clamp(x, getWidth() - getPaddingRight() - getPaddingLeft(), child.getWidth());  
					y = clamp(y, getHeight() - getPaddingBottom() - getPaddingTop(), child.getHeight());  
					super.scrollTo(x, y);  
				}  
				awakenScrollBars();  

				// Keep on drawing until the animation has finished.  
				postInvalidate();  
			}  
		}  

		/** 
		 * Scrolls the view to the given child. 
		 * 
		 * @param child the View to scroll to 
		 */  
		private void scrollToChild(View child) {  
			child.getDrawingRect(mTempRect);  

			/* Offset from child's local coordinates to ScrollView coordinates */  
			offsetDescendantRectToMyCoords(child, mTempRect);  

			int scrollDeltaV = computeScrollDeltaToGetChildRectOnScreenV(mTempRect);  
			int scrollDeltaH = computeScrollDeltaToGetChildRectOnScreenH(mTempRect);  

			if (scrollDeltaH != 0 || scrollDeltaV != 0) {  
				scrollBy(scrollDeltaH, scrollDeltaV);  
			}  
		}  

		/** 
		 * If rect is off screen, scroll just enough to get it (or at least the 
		 * first screen size chunk of it) on screen. 
		 * 
		 * @param rect      The rectangle. 
		 * @param immediate True to scroll immediately without animation 
		 * @return true if scrolling was performed 
		 */  
		public boolean scrollToChildRect(Rect rect, boolean immediate) {  
			final int deltaV = computeScrollDeltaToGetChildRectOnScreenV(rect);  
			final int deltaH = computeScrollDeltaToGetChildRectOnScreenH(rect);  
			final boolean scroll = deltaH != 0 || deltaV != 0;  
			if (scroll) {  
				if (immediate) {  
					scrollBy(deltaH, deltaV);  
				} else {  
					smoothScrollBy(deltaH, deltaV);  
				}  
			}  
			return scroll;  
		}
		/** 
		 * Compute the amount to scroll in the Y direction in order to get 
		 * a rectangle completely on the screen (or, if taller than the screen, 
		 * at least the first screen size chunk of it). 
		 * 
		 * @param rect The rect. 
		 * @return The scroll delta. 
		 */  
		protected int computeScrollDeltaToGetChildRectOnScreenV(Rect rect) {  
			if (getChildCount() == 0) return 0;  

			int height = getHeight();  
			int screenTop = getScrollY();  
			int screenBottom = screenTop + height;  

			int fadingEdge = getVerticalFadingEdgeLength();  

			// leave room for top fading edge as long as rect isn't at very top  
			if (rect.top > 0) {  
				screenTop += fadingEdge;  
			}  

			// leave room for bottom fading edge as long as rect isn't at very bottom  
			if (rect.bottom < getChildAt(0).getHeight()) {  
				screenBottom -= fadingEdge;  
			}  

			int scrollYDelta = 0;  

			if (rect.bottom > screenBottom && rect.top > screenTop) {  
				// need to move down to get it in view: move down just enough so  
				// that the entire rectangle is in view (or at least the first  
				// screen size chunk).  

				if (rect.height() > height) {  
					// just enough to get screen size chunk on  
					scrollYDelta += (rect.top - screenTop);  
				} else {  
					// get entire rect at bottom of screen  
					scrollYDelta += (rect.bottom - screenBottom);  
				}  

				// make sure we aren't scrolling beyond the end of our content  
				int bottom = getChildAt(0).getBottom();  
				int distanceToBottom = bottom - screenBottom;  
				scrollYDelta = Math.min(scrollYDelta, distanceToBottom);  

			} else if (rect.top < screenTop && rect.bottom < screenBottom) {  
				// need to move up to get it in view: move up just enough so that  
				// entire rectangle is in view (or at least the first screen  
				// size chunk of it).  

				if (rect.height() > height) {  
					// screen size chunk  
					scrollYDelta -= (screenBottom - rect.bottom);  
				} else {  
					// entire rect at top  
					scrollYDelta -= (screenTop - rect.top);  
				}  

				// make sure we aren't scrolling any further than the top our content  
				scrollYDelta = Math.max(scrollYDelta, -getScrollY());  
			}  
			return scrollYDelta;  
		}  

		protected int computeScrollDeltaToGetChildRectOnScreenH(Rect rect) {  
			if (getChildCount() == 0) return 0;  

			int width = getWidth();  
			int screenLeft = getScrollX();  
			int screenRight = screenLeft + width;  

			int fadingEdge = getHorizontalFadingEdgeLength();  

			// leave room for left fading edge as long as rect isn't at very left  
			if (rect.left > 0) {  
				screenLeft += fadingEdge;  
			}  

			// leave room for right fading edge as long as rect isn't at very right  
			if (rect.right < getChildAt(0).getWidth()) {  
				screenRight -= fadingEdge;  
			}  

			int scrollXDelta = 0;  

			if (rect.right > screenRight && rect.left > screenLeft) {  
				// need to move right to get it in view: move right just enough so  
				// that the entire rectangle is in view (or at least the first  
				// screen size chunk).  

				if (rect.width() > width) {  
					// just enough to get screen size chunk on  
					scrollXDelta += (rect.left - screenLeft);  
				} else {  
					// get entire rect at right of screen  
					scrollXDelta += (rect.right - screenRight);  
				}  

				// make sure we aren't scrolling beyond the end of our content  
				int right = getChildAt(0).getRight();  
				int distanceToRight = right - screenRight;  
				scrollXDelta = Math.min(scrollXDelta, distanceToRight);  

			} else if (rect.left < screenLeft && rect.right < screenRight) {  
				// need to move right to get it in view: move right just enough so that  
				// entire rectangle is in view (or at least the first screen  
				// size chunk of it).  

				if (rect.width() > width) {  
					// screen size chunk  
					scrollXDelta -= (screenRight - rect.right);  
				} else {  
					// entire rect at left  
					scrollXDelta -= (screenLeft - rect.left);  
				}  

				// make sure we aren't scrolling any further than the left our content  
				scrollXDelta = Math.max(scrollXDelta, -getScrollX());  
			}  
			return scrollXDelta;  
		}  

		@Override  
		public void requestChildFocus(View child, View focused) {  
			if (!mScrollViewMovedFocus) {  
				if (!mIsLayoutDirty) {  
					scrollToChild(focused);  
				} else {  
					// The child may not be laid out yet, we can't compute the scroll yet  
					mChildToScrollTo = focused;  
				}  
			}  
			super.requestChildFocus(child, focused);  
		}  


		/** 
		 * When looking for focus in children of a scroll view, need to be a little 
		 * more careful not to give focus to something that is scrolled off screen. 
		 * 
		 * This is more expensive than the default {@link android.view.ViewGroup} 
		 * implementation, otherwise this behavior might have been made the default. 
		 */  
		@Override  
		protected boolean onRequestFocusInDescendants(int direction,  
				Rect previouslyFocusedRect) {  

			// convert from forward / backward notation to up / down / left / right  
			// (ugh).  
			//        if (direction == View.FOCUS_FORWARD) {  
			//            direction = View.FOCUS_RIGHT;  
			//        } else if (direction == View.FOCUS_BACKWARD) {  
			//            direction = View.FOCUS_LEFT;  
			//        }  
			 if (direction == View.FOCUS_FORWARD) {  
	             direction = View.FOCUS_RIGHT;  
	         } else if (direction == View.FOCUS_BACKWARD) {  
	             direction = View.FOCUS_LEFT;  
			 } 
			
			
			final View nextFocus = previouslyFocusedRect == null ?  
					FocusFinder.getInstance().findNextFocus(this, null, direction) :  
						FocusFinder.getInstance().findNextFocusFromRect(this,  
								previouslyFocusedRect, direction);  

					if (nextFocus == null) {  
						return false;  
					}  

					//        if (isOffScreenH(nextFocus)) {  
						//            return false;  
					//        }  

					return nextFocus.requestFocus(direction, previouslyFocusedRect);  
		}    

		@Override  
		public boolean requestChildRectangleOnScreen(View child, Rect rectangle,  
				boolean immediate) {  
			// offset into coordinate space of this scroll view  
			rectangle.offset(child.getLeft() - child.getScrollX(),  
					child.getTop() - child.getScrollY());  

			return scrollToChildRect(rectangle, immediate);  
		}  

		@Override  
		public void requestLayout() {  
			mIsLayoutDirty = true;  
			super.requestLayout();  
		}  

		@Override  
		protected void onLayout(boolean changed, int l, int t, int r, int b) {  
			super.onLayout(changed, l, t, r, b);  
			mIsLayoutDirty = false;  
			// Give a child focus if it needs it   
			if (mChildToScrollTo != null && isViewDescendantOf(mChildToScrollTo, this)) {  
				scrollToChild(mChildToScrollTo);
			}  
			mChildToScrollTo = null;  

			// Calling this with the present values causes it to re-clam them  
			scrollTo(getScrollX(), getScrollY());  
		}  

		@Override  
		protected void onSizeChanged(int w, int h, int oldw, int oldh) {  
			super.onSizeChanged(w, h, oldw, oldh);  

			View currentFocused = findFocus();  
			if (null == currentFocused || this == currentFocused)  
				return;  

			// If the currently-focused view was visible on the screen when the  
			// screen was at the old height, then scroll the screen to make that  
			// view visible with the new screen height.  
			if (isWithinDeltaOfScreenV(currentFocused, 0, oldh)) {  
				currentFocused.getDrawingRect(mTempRect);  
				offsetDescendantRectToMyCoords(currentFocused, mTempRect);  
				int scrollDelta = computeScrollDeltaToGetChildRectOnScreenV(mTempRect);  
				doScrollY(scrollDelta);  
			}  

			final int maxJump = getRight() - getLeft();  
			if (isWithinDeltaOfScreenH(currentFocused, maxJump)) {  
				currentFocused.getDrawingRect(mTempRect);  
				offsetDescendantRectToMyCoords(currentFocused, mTempRect);  
				int scrollDelta = computeScrollDeltaToGetChildRectOnScreenH(mTempRect);  
				doScrollX(scrollDelta);  
			}  
		}      

		/** 
		 * Return true if child is an descendant of parent, (or equal to the parent). 
		 */  
		private boolean isViewDescendantOf(View child, View parent) {  
			if (child == parent) {  
				return true;  
			}  

			final ViewParent theParent = child.getParent();  
			return (theParent instanceof ViewGroup) && isViewDescendantOf((View) theParent, parent);  
		}      

		/** 
		 * Fling the scroll view 
		 * 
		 * @param velocityY The initial velocity in the Y direction. Positive 
		 *                  numbers mean that the finger/cursor is moving down the screen, 
		 *                  which means we want to scroll towards the top. 
		 */  
		public void fling(int velocityX, int velocityY) {  
			if (getChildCount() > 0) {  
				int width = getWidth() - getPaddingRight() - getPaddingLeft();  
				int right = getChildAt(0).getWidth();  

				int height = getHeight() - getPaddingBottom() - getPaddingTop();  
				int bottom = getChildAt(0).getHeight();  

				mScroller.fling(getScrollX(), getScrollY(), velocityX, velocityY,   
						0, Math.max(0, right - width),   
						0, Math.max(0, bottom - height));  

				//            final boolean movingDown = velocityX > 0 || velocityY > 0;  
				//      
				//            View newFocused =  
				//                    findFocusableViewInMyBoundsV(movingDown, mScroller.getFinalY(), findFocus());  
				//            if (newFocused == null) {  
				//                newFocused = this;  
				//            }  
				//      
				//            if (newFocused != findFocus()  
				//                    && newFocused.requestFocus(movingDown ? View.FOCUS_DOWN : View.FOCUS_UP)) {  
				//                mScrollViewMovedFocus = true;  
				//                mScrollViewMovedFocus = false;  
				//            }  

				invalidate();  
			}  
		}  

		/** 
		 * {@inheritDoc} 
		 * 
		 * <p>This version also clamps the scrolling to the bounds of our child. 
		 */  
		@Override  
		public void scrollTo(int x, int y) {  
			// we rely on the fact the View.scrollBy calls scrollTo.  
			if (getChildCount() > 0) {  
				View child = getChildAt(0);  
				x = clamp(x, getWidth() - getPaddingRight() - getPaddingLeft(), child.getWidth());  
				y = clamp(y, getHeight() - getPaddingBottom() - getPaddingTop(), child.getHeight());  
				if (x != getScrollX() || y != getScrollY()) {  
					super.scrollTo(x, y);  
				}  
			}  
		}  

		private int clamp(int n, int my, int child) {  
			if (my >= child || n < 0) {  
				/* my >= child is this case: 
				 *                    |--------------- me ---------------| 
				 *     |------ child ------| 
				 * or 
				 *     |--------------- me ---------------| 
				 *            |------ child ------| 
				 * or 
				 *     |--------------- me ---------------| 
				 *                                  |------ child ------| 
				 * 
				 * n < 0 is this case: 
				 *     |------ me ------| 
				 *                    |-------- child --------| 
				 *     |-- mScrollX --| 
				 */  
				return 0;  
			}  
			if ((my+n) > child) {  
				/* this case: 
				 *                    |------ me ------| 
				 *     |------ child ------| 
				 *     |-- mScrollX --| 
				 */  
				return child-my;  
			}  
			return n;  
		}  

		public boolean isFlingEnabled() {  
			return mFlingEnabled;  
		}  

		public void setFlingEnabled(boolean flingEnabled) {  
			this.mFlingEnabled = flingEnabled;  
		}  
	} 
}

